home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / REFERENC / TPR / TPR4A.TXT < prev    next >
Text File  |  1992-10-19  |  72KB  |  2,061 lines
  1.                                    Chapter 4
  2.                                     of the
  3.                             Turbo Pascal Reference
  4.  
  5.                          The System Library Reference
  6.  
  7. This chapter is part of the Turbo Pascal Reference electronic freeware book (C)
  8. Copyright 1992 by Ed Mitchell.  This freeware book contains supplementary
  9. material to Borland Pascal Developer's Guide, published by Que Corporation,
  10. 1992.  However, Que Corporation has no affiliation with nor responsibility for
  11. the content of this free book.  Please see Chapter 1 of the Turbo Pascal
  12. Reference for important information about your right to distribute and use this
  13. material freely.  If you find this material of use, I would appreciate your
  14. purchase of one my books, such as the Borland Pascal Developer's Guide or
  15. Secrets of the Borland C++ Masters, Sams Books, 1992.  Thank you.
  16.  
  17. Note:  For ease of access, Chapter 4 is continued in TPR4B.TXT.
  18.  
  19.  
  20.      The System Library contains several standard units, including System, Crt,
  21. Dos, Overlay and Printer.  These units provide a large set of routines for
  22. performing input and output, file system access and file manipulation, access
  23. to DOS, full text screen support including selecting foreground and background
  24. colors, mathematical functions and other features.  This section describes the
  25. available library routines.  The Overlay and Graph units are described in the
  26. Borland Pascal Developer's Guide, Que Books, 1992.  The System Library
  27. Reference contains, in alphabetical order, explanations and sample code for the
  28. functions, procedure and variables defined in each of the units.  
  29.      The procedures and functions contained in the System unit are directly
  30. accessible to your programs and units at all times; you do not need to use the
  31. System unit.  However, the procedures and functions available in the Crt, Dos,
  32. Graph, Overlay and Printer units require that these units be named in a uses
  33. statement in your program or unit.  
  34.      The contents of the System, Crt, Dos, Overlay and Printer units are
  35. normally contained in the TURBO.TPL library file.  You can add or delete units
  36. in TURBO.TPL using the TPUMOVER utility (see "Using TPUMOVER to Update
  37. TURBO.TPL" in chapter 2, "Units and Dynamic Link Libraries" in the Borland
  38. Pascal Developer's Guide (Que Books, 1992)).   The GRAPH unit, due to its size,
  39. is kept in a separate GRAPH.TPU file.
  40.  
  41.  
  42. Overcoming Potential Name Conflicts
  43.      Occassionally a unit procedure or function identifier will conflict with
  44. one of your own identifiers.  When this occurs,  you can still access the
  45. library identifier by prefacing it with its unit name.  For example,
  46. System.Abs, or Dos.GetTime.
  47.  
  48.  
  49. Quick Reference to
  50.      Crt, Dos and System Unit Procedures and Functions
  51.  
  52. Unit: Crt
  53.  
  54.      procedure AssignCrt(var F: Text);
  55.      procedure ClrEol;
  56.      procedure ClrScr;
  57.      procedure Delay(MS: Word);
  58.      procedure DelLine;
  59.      procedure GotoXY(X,Y: Byte);
  60.      procedure HighVideo;
  61.      procedure InsLine;
  62.      function  KeyPressed: Boolean;
  63.      procedure LowVideo;
  64.      procedure NormVideo;
  65.      procedure NoSound;
  66.      function  ReadKey: Char;
  67.      procedure Sound(Hz: Word);
  68.      procedure TextBackground(Color: Byte);
  69.      procedure TextColor(Color: Byte);
  70.      procedure TextMode(Mode: Integer);
  71.      function  WhereX: Byte;
  72.      function  WhereY: Byte;
  73.      procedure Window(X1,Y1,X2,Y2: Byte);
  74.  
  75. Unit: Dos
  76.      function  DiskFree(Drive: Byte): Longint;
  77.      function  DiskSize(Drive: Byte): Longint;
  78.      function  DosVersion: Word;
  79.      function  DosExitCode: Word;
  80.      function  EnvCount: Integer;
  81.      function  EnvStr(Index: Integer): String;
  82.      procedure Exec(Path: PathStr; ComLine: ComStr);
  83.      function  FExpand(Path: PathStr): PathStr;
  84.      procedure FindFirst(Path: PathStr; Attr: Word; var F: SearchRec);
  85.      procedure FindNext(var F: SearchRec);
  86.      function  FSearch(Path: PathStr; DirList: String): PathStr;
  87.      procedure FSplit(Path: PathStr; var Dir: DirStr; 
  88.                          var Name: NameStr; var Ext: ExtStr);
  89.      procedure GetCBreak(var Break: Boolean);
  90.      procedure GetDate(var Year,Month,Day,DayOfWeek: Word);
  91.      function  GetEnv(EnvVar: String): String;
  92.      procedure GetIntVec(IntNo: Byte; var Vector: Pointer);
  93.      procedure GetFAttr(var F; var Attr: Word);
  94.      procedure GetFTime(var F; var Time: Longint);
  95.      procedure GetTime(var Hour,Minute,Second,Sec100: Word);
  96.      procedure GetVerify(var Verify: Boolean);
  97.      procedure Intr(IntNo: Byte; var Regs: Registers);
  98.      procedure Keep(ExitCode: Word);
  99.      procedure MsDos(var Regs: Registers);
  100.      procedure PackTime(var T: DateTime; var P: Longint);
  101.      procedure SetCBreak(Break: Boolean);
  102.      procedure SetDate(Year,Month,Day: Word);
  103.      procedure SetFAttr(var F; Attr: Word);
  104.      procedure SetFTime(var F; Time: Longint);
  105.      procedure SetIntVec(IntNo: Byte; Vector: Pointer);
  106.      procedure SetTime(Hour,Minute,Second,Sec100: Word);
  107.      procedure SetVerify(Verify: Boolean);
  108.      procedure SwapVectors;
  109.      procedure UnpackTime(P: Longint; var T: DateTime);
  110.  
  111. Unit: System
  112.      function  Abs( X : Integer) : Integer; { Note result type is same as }
  113.      function  Abs( X : Real ) : Real; { parameter type }
  114.      function  Addr ( X ) : Pointer;
  115.      procedure Append ( var F : Text );
  116.      function  ArcTan ( X: Real );
  117.      procedure AssignCrt(var F: Text );
  118.      procedure BlockRead( var F: File; var Buf; Count: Word [; var Result:
  119. Word]);
  120.      procedure BlockWrite( var F: File; var Buf; Count : Word [; var Result:
  121. Word]);
  122.      function  Chr( X : Byte) : Char;
  123.      procedure Close (var F);
  124.      function  Concat ( S1 [, S2, ... Sn] : String ) :String;
  125.      function  Copy ( S: String; Index : Integer; Count: Integer ) : String;
  126.      function  Cos( X : Real );
  127.      function  CSeg : Word;
  128.      procedure Dec ( var X [; N : Longint] );
  129.      procedure Delete(var S: String; Index: Integer; Count: Integer);
  130.      procedure Dispose ( var P : Pointer [, Destructor] );
  131.      function  DSeg : Word;
  132.      function  Eof : Boolean;
  133.      function  Eof(var F: Text): Boolean;
  134.      function  Eof(var F): Boolean;
  135.      function  Eoln : Boolean;
  136.      function  Eoln(var F: Text): Boolean;
  137.      procedure Erase ( var F: File );
  138.      procedure Exit;
  139.      function  Exp( X: Real ): Real;
  140.      function  FilePos ( var F ): Longint;
  141.      function  FileSize ( var F ) : Longint;
  142.      procedure FillChar( var X; Count : Word; Value );
  143.      procedure Flush ( var F: Text );
  144.      function  Frac ( X: Real ): Real;
  145.      procedure FreeMem (var P: Pointer; Size : Word );
  146.      function  FSearch( Path: PathStr; DirList: String ): PathStr;
  147.      procedure FSplit ( Path : PathStr; var Dir: DirStr;
  148.                          var Name: NameStr; var Ext: ExtStr );
  149.      procedure GetDate(var Year, Month, Day, DayofWeek: Word);
  150.      procedure GetDir( D: Byte; var S: String );
  151.      procedure GetIntVec(IntNo: Byte; var Vector:Pointer);
  152.      procedure GetMem(var P: Pointer; Size: Word);
  153.      procedure GetTime(var Hour, Minute, Second, Sec100:Word);
  154.      procedure Halt [ (ExitCode: Word); ]
  155.      function  Hi ( X ) : Byte;
  156.      procedure Inc (var X [; N: Longint ] );
  157.      procedure Insert( Source: String; var S: String;Index: Integer);
  158.      function  Int( X: Real ) : Real;
  159.      function  IOResult : Word;
  160.      function  Length ( S : String );
  161.      function  Ln( X : Real );
  162.      function  Lo(X): Byte;
  163.      procedure Mark (var P: Pointer);
  164.      function  MaxAvail : Longint;
  165.      function  MemAvail : Longint;
  166.      procedure MkDir(S: String);
  167.      procedure Move (var Source, Dest; Count : Word);
  168.      procedure New( var P: Pointer [, Init: constructor] );
  169.      function  Odd( X: Longint ): Boolean;
  170.      function  Ofs( X ): Word;
  171.      function  Ord( X ): Longint;
  172.      procedure PackTime(var DT: DateTime; var Time:Longint);
  173.      function  ParamCount : Word;
  174.      function  ParamStr( Index: Word ) : String;
  175.      function  Pi : Real;
  176.      function  Pos ( Substr, S: String ): Byte;
  177.      function  Pred( X ) : <same type as X>;
  178.      function  Ptr( Seg, Ofs : Word) : Pointer;
  179.      function  Random [ (Range: Word) ] : Word;
  180.      function  Random [ (Range: Word) ] : Real;
  181.      procedure Randomize;
  182.      procedure Read( [var F: Text; ] V1 [, V2, ..., Vn ]);
  183.      procedure Read ( F, V1 [, V2, ..., Vn ] );
  184.      procedure Readln( [var F: Text; ] [V1, V2, ..., Vn ] );
  185.      procedure Release (var P: Pointer);
  186.      procedure Rename(var F; Newname : String );
  187.      procedure Reset (var F [: File; RecSize: Word] );
  188.      procedure Rewrite (var F [: File; RecSize: Word] );
  189.      procedure RmDir ( S: String );
  190.      procedure Round ( X: Real );
  191.      procedure RunError [ ( ErrorCode: Byte ) ];
  192.      procedure Seek(var F; N: Longint);
  193.      function  SeekEof [  ( var F: Text ); ]
  194.      function  SeekEoln[ (var F: Text); ]
  195.      function  Seg(X): Word;
  196.      procedure SetTextBuf(var F: Text; var Buf [; Size:Word ] );
  197.      procedure SetTime(Hour, Minute, Second, Sec100:Word);
  198.      function  Sin ( X: Real ) : Real;
  199.      function  SizeOf( X ) : Word;
  200.      function  SPtr : Word;
  201.      function  Sqr( X ) : <type of X>
  202.      function  Sqrt(X: Real) : Real;
  203.      function  SSeg: Word;
  204.      procedure Str(X [: Width [:Decimals] ]; var S:);
  205.      function  Succ(X) : <same type as X>;
  206.      function  Swap(X) : <same type as X>;
  207.      function  Trunc( X: Real ): Longint;
  208.      procedure Truncate(var F);
  209.      procedure UnpackTime(Time: Longint; var DT:DateTime);
  210.      function  UpCase (Ch: Char): Char;
  211.      procedure Val(S: String; var V; var Code: Integer);
  212.      procedure Write( [ var F: Text; ] V1 [, V2, ..., Vn] );
  213.      procedure Write( var F; V1, [, V2, ..., Nn ] );
  214.      procedure Writeln( [var F:Text; ] [V1 [V2, ..., Vn]] );
  215.  
  216.  
  217.  
  218.  
  219.                                Reference Section
  220.  
  221.  
  222. Abs function
  223. ----------------------------------------------------------------
  224. Declaration:
  225.    function Abs( X : Integer) : Integer;
  226.    function Abs( X : Real ) : Real;
  227.  
  228. Example:
  229.  
  230.    Writeln ( Abs( 3.14159 ):6:5 );
  231.    Writeln( Abs( -3.14159 ):6:5);
  232.    Writeln ( Abs (-3 ) );
  233.  
  234. outputs,
  235.    3.14159
  236.    3.14159
  237.    3
  238.  
  239. Purpose:
  240.    If X is less than zero, then Abs returns -X, hence, converting X to a
  241. positive value.  If X is greater than zero, then Abs returns X.  Abs assumes
  242. the data type of the parameter, either integer or real.
  243.  
  244.  
  245.  
  246. Addr Function
  247. ----------------------------------------------------------------
  248. Declaration:  
  249.    function Addr ( X ) : Pointer;
  250.  
  251. Example:
  252.    var
  253.      S : String;
  254.      PS : ^String;
  255.    ...
  256.    S := 'This is only a test!';
  257.    PS := Addr ( S );
  258.    Writeln( PS^ );
  259.  
  260. Purpose:
  261.    Like the @ address-of operator, Addr returns the memory address of its
  262. operand.  The statement,
  263.    PS := Addr(S);
  264. is equivalent to writing,
  265.    PS := @S;
  266.  
  267.  
  268.  
  269. Append procedure
  270. ----------------------------------------------------------------
  271. Declaration:  
  272.    procedure Append ( var F : Text );
  273.  
  274. Example:
  275.    var
  276.      TextFile : Text;
  277.    ...
  278.    Assign ( TextFile, 'OLDFILE.TXT' );
  279.    Append ( TextFile );
  280.    Writeln ('This will be written at the end of the existing file
  281. OLDFILE.TXT');
  282.  
  283. Purpose:
  284.    Like Reset, Append is used to open a text file, but instead of positioning
  285. the file pointer to the beginning of the file, Append places the file pointer
  286. at the very end.  This way, subsequent writes are appended to the existing data
  287. in the text file.  Obviously, the file identifier opened by Append becomes a
  288. write-only file type.
  289.  
  290.  
  291.  
  292. ArcCos/ArcSin functions
  293. ----------------------------------------------------------------
  294. The Turbo Pascal library omits arc-sine and arc-cosine functions.  However,
  295. these functions may be calculated using the the relations shown in these
  296. function definitions, returning a result in the range of [-Pi/2 .. Pi/2 ]:
  297.  
  298.    function ArcCos ( X : Real ): Real;
  299.    var
  300.      TempArcCos : Real;
  301.    begin
  302.      if X = 0.0 then { to avoid division by 0 }
  303.        TempArcCos := Pi / 2.0
  304.      else
  305.        TempArcCos := ArcTan ( Sqrt ( 1 - X*X ) / X );
  306.      if  X < 0.0  then
  307.        TempArcCos := PI - TempArcCos;
  308.      ArcCos := TempArcCos;
  309.    end;
  310.  
  311.    function ArcSin ( X : Real ): Real;
  312.    begin
  313.      if X = 1.0 then { to avoid division by 0 }
  314.        ArcSin := Pi / 2.0
  315.      else
  316.        ArcSin := ArcTan ( X / Sqrt ( 1 - X * X ) );
  317.    end;
  318.  
  319. See ArcTan, Cos, Sin, Sqrt, Tan
  320.  
  321.  
  322.  
  323. ArcTan function
  324. ----------------------------------------------------------------
  325. Declaration:  
  326.    function ArcTan ( X: Real );
  327.  
  328. Purpose:
  329.    Computes the arc-tangent of X, returning an angle measurement, in radians.
  330. See ArcCos/ArcSin, Cos, Sin, Tan
  331.  
  332.  
  333.  
  334. Assign procedure
  335. ----------------------------------------------------------------
  336. Declaration:  
  337.      procedure Assign( var F; Name : String );
  338.  
  339. Example:
  340.      var
  341.        InputFile : Text;
  342.      ...
  343.        Assign ( InputFile, 'DATA.TXT' );
  344.        {$I-}
  345.        Reset ( InputFile );
  346.  
  347. Purpose:
  348.      Associates the filename Name with the file identifier F, where Name
  349. contains a standard DOS filename, optionally including drive and path
  350. specifications up to 79 characters in length and F is of any file type.  You
  351. must use Assign before opening a file with Reset, Rewrite or Append, or when
  352. using the Erase or Rename procedures.
  353.      If you Assign the null string to a file identifier, as,
  354.      Assign ( InputFile, '' );
  355. a subsequent Reset opens the DOS standard input file and a Rewrite opens the
  356. DOS standard output.  The standard input and output files may be used with DOS
  357. command line redirection.
  358. See Append, Close, Reset, Rewrite, and "File Operations" in chapter 3 of the
  359. Turbo Pascal Reference.
  360.  
  361.  
  362.  
  363. AssignCrt procedure
  364. ----------------------------------------------------------------
  365. Declaration:  
  366.      procedure AssignCrt(var F: Text );
  367.  
  368. Unit:       Crt
  369.  
  370. Example:
  371.      if UseScreen then
  372.        AssignCrt( OutFile )
  373.      else
  374.        AssignCrt( OutFile, 'OUTPUT.TXT' );
  375.      Rewrite ( OutFile );
  376.      Writeln ( OutFile, 'Report of Summer Activities');
  377.      Writeln( OutFile );
  378.      
  379. Purpose:
  380.      AssignCrt is used in conjunction with Reset and Rewrite, to access the Crt
  381. screen as a file.  AssignCrt may be used to provide an option in your program
  382. to direct output to either a file or to the screen.  When file output is
  383. selected, use Assign to specify the output text file.  When the screen is
  384. requested, use AssignCrt.  Then, after using Rewrite to open the output device,
  385. your Write statements will route your output to the file or the screen,
  386. depending upon how you made the initial assignment to the file identifier.
  387. See Assign, Close, Reset, Rewrite
  388.  
  389.  
  390.  
  391. BlockRead procedure
  392. ----------------------------------------------------------------
  393. Declaration:  
  394.      procedure BlockRead( var F: File; var Buf; Count: Word
  395.               [; var Result: Word] );
  396.  
  397. Example:
  398.      See "File Operations" in chapter 3 of Turbo Pascal Reference.
  399.  
  400. Purpose:
  401.      BlockRead reads Count * RecSize bytes from the untyped file F, and places
  402. them in Buf where Buf is typically an array of byte or char of the appropriate
  403. size.  RecSize is the record size specified as the optional second parameter to
  404. Reset or Rewrite, or the default value of 128 if no record size is specified.  
  405. You may optionally add a Result variable parameter which returns the actual
  406. number of complete records read.  In the event that the end of file is reached
  407. in the middle of a record, the last partial record will not be included in the
  408. Result value.  If you do not use the Result variable in the call to BlockRead,
  409. you should set the {$I-} compiler directive and check IOResult after ever call
  410. to BlockRead.
  411. See "Disk File Operations" in chapter 2, BlockWrite, IOResult, Reset, Rewrite
  412.  
  413.  
  414.  
  415. BlockWrite procedure
  416. ----------------------------------------------------------------
  417. Declaration:  
  418.      procedure BlockWrite( var F: File; var Buf; Count : Word
  419.           [; var Result : Word]);
  420.  
  421. Example:
  422.      See "Disk File Operations" in chapter 3 of Turbo Pascal Reference.
  423.  
  424. Purpose:
  425.      BlockWrite writes Count * RecSize bytes from Buf to the untyped file F. 
  426. RecSize is either the default value of 128, or is the record size specified as
  427. the optional second parameter of Reset or Rewrite, and Buf is usually an array
  428. of byte or char values.  The optional Result variable parameter returns the
  429. number of complete records actually written to the file.  If you do not use the
  430. Result variable in the call to BlockWrite, you should set the {$I-} compiler
  431. directive and check IOResult after ever call to BlockWrite.
  432. See "Disk File Operations" in chapter 3, BlockRead, Reset, Rewrite
  433.  
  434.  
  435.  
  436. CheckBreak
  437. ----------------------------------------------------------------
  438. Declaration:  
  439.      CheckBreak: Boolean; {Default = True}
  440.  
  441. Unit:       Crt
  442.  
  443. Purpose:
  444.      By setting CheckBreak to False, you can disable the Ctrl-Break key, used
  445. to interrupt program execution.  When CheckBreak is True, pressing Ctrl-Break
  446. will terminate program execution at the next output sent to the screen.
  447. See GetCBreak, SetCBreak
  448.  
  449.  
  450.  
  451. CheckEOF
  452. ----------------------------------------------------------------
  453. Declaration:  
  454.      CheckEOF : Boolean; {Default = False}
  455.  
  456. Unit:       Crt
  457.  
  458. Purpose:
  459.      If you press Ctrl-Z at the keyboard, an end-of-file character may be
  460. returned to the input, depending on the setting of CheckEof.  Setting CheckEof
  461. to True enables end-of-file character generation; setting CheckEof to False
  462. disables this operation.
  463.  
  464.  
  465.  
  466. CheckSnow
  467. ----------------------------------------------------------------
  468. Declaration:  
  469.      CheckSnow: Boolean; {Default = True}
  470.  
  471. Unit:       Crt
  472.  
  473. Purpose:
  474.      The setting of CheckSnow is used in conjunction with the DirectVideo
  475. boolean variable.  On older or less expensive CGA color displays, the color
  476. graphics adaptor uses single ported memory.  When the video display circuitry
  477. and the CPU both try to access the memory at the same time a video effect
  478. referred to as "snow" appears on the screen.  The solution to this problem
  479. involves changing the low level output routines so that the CPU only updates
  480. the video memory area during horizontal or vertical screen retrace intervals. 
  481. You don't need to worry about the technical details of all that.  However, if,
  482. when running your applications in a color display environment and you see snow
  483. or static on the screen, set CheckSnow to True.  As a last resort, you may need
  484. to set DirectVideo to False, however, this will result in extremely slow screen
  485. updates since all screen I/O will be forced to go through the BIOS interface.
  486.      According to Borland, the value of CheckSnow defaults to True, initially. 
  487. However, I found that on my system, CheckSnow defaults to False.  For fastest
  488. video output, you want CheckSnow to be False and DirectVideo to be True,
  489. consistent with avoiding a video snow fall.
  490. See DirectVideo
  491.  
  492.  
  493.  
  494. ChDir procedure
  495. ----------------------------------------------------------------
  496. Declaration:  
  497.      procedure ChDir ( S : String );
  498.  
  499. Example:
  500.  
  501.      {$I-}
  502.      ChDir('\TP\UTILS');
  503.      ErrCode := IOResult;
  504.      if ErrCode <> 0 then { handle error condition ... }
  505.  
  506. Purpose:
  507.      Changes the current subdirectory to the directory specified by the string
  508. S.  ChDir works the same as the DOS commands CD or CHDIR, making the directory
  509. in S the current working directory.  You may also include a drive name, by
  510. prefacing the subdirectory pathname with the drive letter, as, 
  511.      ChrDir ('D:\TP\UTILS');
  512.  
  513.  
  514.  
  515. Chr function
  516. ----------------------------------------------------------------
  517. Declaration:  
  518.      function Chr( X : Byte) : Char;
  519.  
  520. Example:
  521.      var
  522.        I : Integer;
  523.        S : String;
  524.      ...
  525.      { Convert all upper case letters to lower case letters }
  526.      for I := 1 to Length(S) do
  527.        if (S[I]>='A') and (S[I]<='Z')  then
  528.           S[I] := Chr( Ord(S[I]) + 32 );
  529.  
  530. Purpose:
  531.      Chr (often pronounced "char") is used to translate the integer valued byte
  532. expression to a char-type value.  Effectively, Chr converts an ASCII character
  533. code in the range 0 to 255 to a character type.  To convert a character value
  534. to an integer, use the Ord function.
  535. See Ord
  536.  
  537.  
  538.  
  539. Close procedure
  540. ----------------------------------------------------------------
  541. Declaration:  
  542.      procedure Close (var F);
  543.  
  544. Example:
  545.  
  546.      Assign ( OutFile, 'SCRATCH.DAT' );
  547.      Rewrite ( OutFile );
  548.      ....
  549.      Close ( OutFile );
  550.  
  551. Purpose:
  552.      When you are finished reading or writing data to a file, that file must be
  553. closed by calling the Close procedure.  For output files, Close causes any
  554. remaining internal buffers to be written to disk.  Failure to call Close may
  555. result in incomplete data being stored in the file.  As with all file
  556. operations, you should se the {$I-} compiler directive and check the value of
  557. IOResult to determine if the Close was successful.
  558. See Append, Assign, Reset, Rewrite
  559.  
  560.  
  561.  
  562. ClrEol procedure
  563. ----------------------------------------------------------------
  564. Declaration:  
  565.      procedure ClrEol;
  566.  
  567. Unit:       Crt
  568.  
  569. Example:
  570.      Gotoxy ( 1, 10 ); { Clear the 10th line down in the screen
  571.                               or Window }
  572.      ClrEol;
  573.  
  574. Purpose:
  575.      Beginning at the current cursor location, ClrEol erases the screen to the
  576. right edge of the screen (or the edge of the viewing window if the Window
  577. procedure has been called), setting the erased area to blanks displayed the
  578. current background color (see TextBackground).  By using Gotoxy to position the
  579. cursor, you can use ClrEol to erase portions of lines anywhere on the screen.
  580. See ClrScr, TextBackground, Window
  581.  
  582.  
  583.  
  584. ClrScr procedure
  585. ----------------------------------------------------------------
  586. Declaration:  
  587.      procedure ClrScr;
  588.  
  589. Unit:       Crt
  590.  
  591. Example:
  592.      { Clear the screen }
  593.      ClrScr;
  594.  
  595. Purpose:
  596.      Clears the display screen (or the area within the region defined by the
  597. Window procedure) and sets the screen color to the current TextBackground
  598. color.  The cursor position is set to the upper left corner of the screen (or
  599. Window region).
  600. See ClrEol, TextBackground, Window
  601.  
  602.  
  603.  
  604. Concat function
  605. ----------------------------------------------------------------
  606. Declaration:  
  607.      function Concat ( S1 [, S2, ... Sn] : String ) : String;
  608.  
  609. Example:
  610.      S := Concat ( 'Hello', ' World', '!' );
  611.      {is equivalent to writing
  612.        S := 'Hello' + ' World' + '!';
  613.      }
  614.  
  615. Purpose:
  616.      Concat takes a parameter list of string values to be concatenated or
  617. joined together, and appends the second string onto the end of the first, and
  618. the third on to the end of that, and so on.  Additional string values, in turn,
  619. are appended to the previously joined values in the list up to a maximum string
  620. length of 255.  Any text beyond 255 characters is disgarded and the result
  621. string is truncated to 255 characters.
  622. See Copy, Delete, Insert, Length, Pos
  623.  
  624.  
  625.  
  626. Copy function
  627. ----------------------------------------------------------------
  628. Declaration:  
  629.      function Copy ( S: String; Index : Integer; 
  630.                     Count : Integer ) : String;
  631.  
  632. Example:
  633.      Writeln( Copy( 'ABCDEFGHIJKLMN', 4, 3 ) );
  634.  
  635. outputs,
  636.  
  637.      DEF
  638.  
  639. Purpose:
  640.      Extracts and returns a subset of string S, beginning at the Index'th
  641. character position and extending for Count bytes.  If Index is greater than
  642. Length(S), Copy returns a null string.  If Index + Count is greater than
  643. Length(S), then Copy returns all the characters between Index and Length(S).
  644.      If you've programmed string operations in the BASIC language, you have
  645. undoubtedly appreciated the convenience of BASIC's LEFT$, MID$ and RIGHT$
  646. functions.  Copy is equivalent to MID$.  By setting Copy's Index to 1, Copy
  647. operates the same as LEFT$.  You can implement a RIGHT$ equivalent function by
  648. writing,
  649.      function Right ( S : String; Index: Integer ) : String;
  650.      begin
  651.        Right := Copy ( S, Length(S) - Index + 1, 255 );
  652.      end;
  653.  
  654. See Concat, Delete, Insert, Length, Pos
  655.  
  656.  
  657.  
  658. Cos function
  659. ----------------------------------------------------------------
  660. Declaration:  
  661.      function Cos( X : Real );
  662.  
  663. Example:
  664.      GetAspectRatio ( Xasp, Yasp );
  665.      { Compute (X,Y) 10% further out than the radius. }
  666.      X := Round( 1.1 * Radius * Cos ( AngleInRadians ) );
  667.      Y := - Round( 1.1 * Radius * Sin ( AngleInRadians ) *
  668.             (Xasp/Yasp));
  669.  
  670. Purpose:
  671.      Computes and returns the cosine of X, where X is an angle measurement in
  672. radians.  Note that many of the graphics routines use an angle measurement in
  673. degrees. To convert from degrees to radians, divide the degree measurement by
  674. 180 / Pi.
  675. See ArcSin/ArcCos, ArcTan, Sin, Tan
  676.  
  677.  
  678.  
  679. CSeg function
  680. ----------------------------------------------------------------
  681. Declaration:  
  682.      function CSeg : Word;
  683.  
  684. Purpose:
  685.      CSeg returns the value of the 80x86 CS register in use by the code that
  686. called CSeg.
  687. See DSeg, SSeg
  688.  
  689.  
  690.  
  691. Dec function
  692. ----------------------------------------------------------------
  693. Declaration:  
  694.      procedure Dec ( var X [; N : Longint] );
  695.  
  696. Example:
  697.      Dec(I);                            { Equivalent to I := I - 1; }
  698.      Dec(I, Amount);          { Equivalent to I := I - Amount; }
  699.  
  700. Purpose:
  701.      If given a single ordinal-type variable parameter, X, Dec uses optimized
  702. code to decrement the value of X by 1 and is equivalent to,
  703.      X := X - 1;
  704. If the second parameter N is given, Dec decrements X by N, and is equivalent to
  705.      X := X - N;
  706. See Inc, Pred, Succ
  707.  
  708.  
  709.  
  710. Delay procedure
  711. ----------------------------------------------------------------
  712. Declaration:  
  713.      procedure Delay (Ms : Word);
  714.  
  715. Unit:       Crt
  716.  
  717. Example:
  718.      repeat
  719.        SetPalette ( Random(GetMaxColors), Random(GetMaxColors));
  720.        Delay ( 50 );
  721.      until Keypressed;
  722.  
  723. Purpose:
  724.      Delays or pauses execution of the program for approximately the number of
  725. milliseconds specified by the parameter Ms.
  726.  
  727.  
  728.  
  729. Delete procedure
  730. ----------------------------------------------------------------
  731. Declaration:  
  732.      procedure Delete(var S: String; Index: Integer; 
  733.        Count: Integer);
  734.  
  735. Example:
  736.      var
  737.        s : string;
  738.      begin
  739.        S:='ABCDEFGHIJKLM';
  740.        Delete(S,4,3);
  741.        Writeln(s);
  742.      end.
  743.  
  744. outputs
  745.  
  746.      ABCGHIJKLM
  747.  
  748. Purpose:
  749.      Removes or deletes a subsection of string S, beginning at the Index'th
  750. position and continuing for Count characters.  To delete all of the characters
  751. to the right of and including the Index position, you can substitute 255 for
  752. the Count parameter, like this:
  753.      Delete(S, IndexPos, 255);
  754. Since IndexPos + Count exceeds the length of the string, the remaining
  755. characters are deleted.  If Index is greater than Length(S) then no characters
  756. are deleted.
  757. See Concat, Copy, Insert, Length, Pos
  758.  
  759.  
  760.      
  761. DelLine procedure
  762. ----------------------------------------------------------------
  763. Declaration:  
  764.      procedure DelLine;
  765.  
  766. Unit:       Crt
  767.  
  768. Example:
  769.      procedure ScrollUp ( Y : Integer; NumLines : Integer );
  770.      var
  771.        I : Integer;
  772.      begin
  773.        Gotoxy ( 1, Y );
  774.        for I := 1 to NumLines do
  775.           DelLine;
  776.      end;
  777.  
  778. Purpose:
  779.      Use DelLine to scroll all the lines below the current cursor location up
  780. by 1 line.  The routine ScrollUp, shown above, implements a generic scroll up
  781. routine useful in a variety of applications.  Since DelLine operates relative
  782. to the current settings of the Window procedure,  DelLine can scroll lines
  783. within the Window region on the screen.
  784. See InsLine, Window
  785.  
  786.  
  787.  
  788. DirectVideo variable
  789. ----------------------------------------------------------------
  790. Declaration:  
  791.      DirectVideo: Boolean; {Default = True}
  792.  
  793. Unit:       Crt
  794.  
  795. Purpose:
  796.      Turbo Pascal programs, like most programs written for the PC family of
  797. computers, perform output to the video display by copying their text and video
  798. attributes directly into the video memory.  This provides the fastest possible
  799. screen updates.  In some situations, this can result in the appearance of
  800. "video snow" or "static".  When this occurs, set the CheckSnow variable to True
  801. (See CheckSnow).
  802.      By setting DirectVideo to False, programs will perform their output by
  803. calling the BIOS video routines.  This results in greatly reduced display
  804. performance.
  805. See CheckSnow
  806.  
  807.  
  808.  
  809. DiskFree function
  810. ----------------------------------------------------------------
  811. Declaration:  
  812.      function DiskFree( Drive: Byte ) : Longint;
  813.  
  814. Unit:       Dos
  815.  
  816. Purpose:
  817.      Where Drive selects a disk drive (0=A, 1=B, 2=C, ...), DiskFree returns
  818. the number of bytes of remaining free space, or -1 if Drive selects a
  819. non-existent drive.
  820. See DiskSize, GetDir
  821.  
  822.  
  823.  
  824. DiskSize function
  825. ----------------------------------------------------------------
  826. Declaration:  
  827.      function DiskSize( Drive: Byte ): Longint;
  828.  
  829. Unit:       Dos
  830.  
  831. Purpose:
  832.      Where Drive selects a disk drive (0=A, 1=B, 2=C, ...), DiskSize returns
  833. the capacity of the drive, in bytes, or -1 if Drive selects a non-existent
  834. drive.
  835. See DiskFree, GetDir          
  836.  
  837.  
  838.  
  839. Dispose procedure
  840. ----------------------------------------------------------------
  841. Declaration:  
  842.      procedure Dispose ( var P : Pointer [, Destructor] );
  843.  
  844. Example:
  845.      type
  846.        PString = ^String;
  847.      var
  848.        S : PString;
  849.      ...
  850.        New( S );
  851.        S^:='Goodbye World!'';
  852.        Dispose (S);
  853.  
  854. Purpose:
  855.      Deallocates the dynamic memory allocation used by the item or object
  856. pointed to by parameter variable P.  When disposing of objects (see chapter 5,
  857. "Object Oriented Programming"), an optional second parameter may specify the
  858. name of the destructor method for the object pointed to by P.  When used in
  859. this form, Dispose first calls the destructor method of the object prior to
  860. deallocating the the memory pointed to by P.
  861.  
  862. Important!
  863.      After calling Dispose, the value of P is no longer valid.  A commom
  864. programming error is to continue using a pointer after it has been deallocated.
  865. Because the pointer may still point to the original location in memory where
  866. the object had been allocated and since that memory may not be immediately
  867. claimed for use by another entity, this will sometimes work temporarily. 
  868. However, to do so is a serious programming error and may cause the program to
  869. crash!  Don't do it!
  870.      When calling Dispose, P must be a valid pointer.  If P does not point to
  871. the memory used by the heap system, Dispose will issue a run-time error and
  872. stop execution of the program.
  873. See FreeMem, GetMem, Mark, New, Release
  874.  
  875.  
  876.  
  877. DosError variable
  878. ----------------------------------------------------------------
  879. Declaration:  
  880.      DosError: Integer;
  881. Unit:       Dos
  882. Purpose:
  883.      DosError contains the DOS result code after performing a DOS procedure
  884. such as FindFirst/FindNext.
  885.  
  886.  
  887.  
  888. DosExitCode function
  889. ----------------------------------------------------------------
  890. Declaration:
  891.      function DosExitCode : Word;
  892.  
  893. Unit:       Dos
  894.  
  895. Purpose:
  896.      When another program, or COMMAND.COM is executed from within the current
  897. program by calling the Exec procedure, the executed program may return a
  898. DOS-level exit code.  The value of this return code may be examined by checking
  899. the result returned by DosExitCode.  The return values correspond to the
  900. following:
  901.      0=normal termination
  902.      1=Subprogram terminated by user pressing Ctrl-C
  903.      2=Subprogram terminated due to a DOS device error (e.g. drive door open)
  904.      3=Subprogram terminated by the Keep procedure.
  905.  
  906. See Exec
  907.  
  908.  
  909.  
  910. DosVersion function
  911. ----------------------------------------------------------------
  912. Declaration:  
  913.      function DosVersion : Word;
  914.  
  915. Unit:       Dos
  916.  
  917. Example:
  918.      See FSearch for an example.
  919.  
  920. Purpose:
  921.      To determine the version of DOS used by the computer that the program is
  922. running on, call DosVersion.  The low byte returns the main version number and
  923. the high byte returns the minor version number.  For example, for DOS 5.0 the
  924. low byte is 5 and the high byte is 0.  You can access the high and low bytes
  925. using the Hi and Lo functions, respectively.
  926. See Hi, Lo
  927.  
  928.  
  929.  
  930. DSeg function
  931. ----------------------------------------------------------------
  932. Declaration:  function DSeg : Word;
  933.  
  934. Purpose:
  935.      Use DSeg to access the current value of the DS register.
  936. See CSeg, SSeg
  937.  
  938.  
  939.  
  940. EnvCount function
  941. ----------------------------------------------------------------
  942. Declaration:
  943.      function EnvCount : Integer;
  944.  
  945. Unit:       Dos
  946.  
  947. Example:
  948.      for I := 1 to EnvCount do
  949.        Writeln ( EnvStr( I ) );
  950.  
  951. Purpose:
  952.      Use EnvCount in conjunction with EnvStr to access the string values stored
  953. in the DOS environment variable area.  The DOS environment keeps track of your
  954. PATH=, COMSPEC=,  SET= statements and so on.  You can access the current values
  955. stored in the DOS environment through the EnvCount variable, which returns the
  956. total number of environment strings (each <variable>=<value> declaration is
  957. treated as a single string), and EnvStr to access the n'th environment string.
  958. See EnvStr, GetEnv
  959.  
  960.  
  961.  
  962. EnvStr function
  963. ----------------------------------------------------------------
  964. Declaration:  
  965.      function EnvStr( Index: Integer );
  966.  
  967. Unit:       Dos
  968.  
  969. Example:
  970.      See EnvCount
  971.  
  972. Purpose:
  973.      When the Index value is in the range of 1 to EnvCount, EnvStr returns the
  974. values of the Index'th environment variable.  If Index is out of range, EnvStr
  975. returns a null string.  Also see Envcount.
  976.  
  977.  
  978.  
  979. Eof function
  980. ----------------------------------------------------------------
  981. Declaration:  
  982.           function Eof : Boolean;
  983.      or
  984.           function Eof( var F: Text ) : Boolean;
  985.      or
  986.           function Eof( var F: File ) : Boolean;
  987.  
  988. Example:
  989.      Program DemoEof;
  990.      var
  991.        InFile : Text;
  992.        TextLine : String;
  993.      begin
  994.        Assign( Infile, 'TEMP.PAS' );
  995.        Reset( Infile );
  996.        while not Eof( Infile ) do
  997.        begin
  998.           Readln( Infile, TextLine );
  999.           Writeln( TextLine );
  1000.        end;
  1001.        Close( Infile );
  1002.      end.
  1003.  
  1004. Purpose:
  1005.      Eof is used to detect the end of a file while reading input from the file.
  1006. In the first form, if Eof specifies no file parameter, Eof checks the standard
  1007. input file and returns True if an end of file condition is detect, otherwise
  1008. False.  Typing Ctrl-Z at the keyboard sets an Eof condition on the standard
  1009. input.
  1010.      When used with a text file, Eof(F) returns True if the current file
  1011. position is past the last character of the file, otherwise False.
  1012.      When used with a typed or untyped file, Eof(F) returns True if the current
  1013. position is past the last record of the file, otherwise False.
  1014.      
  1015.  
  1016.  
  1017. Eoln function
  1018. ----------------------------------------------------------------
  1019. Declaration:
  1020.           function Eoln : Boolean;
  1021.      or
  1022.           function Eoln ( var F : Text ) : Boolean;
  1023.  
  1024. Example:
  1025.  
  1026. while not Eoln do   { Reads characters until Enter pressed }
  1027.   Read(ch);
  1028.  
  1029. Purpose:
  1030.      Whenever Eoln is called, Eoln returns True if the current location in the
  1031. file is an end-of-line (or carriage-return) marker, or False if it is not. 
  1032. Whenused without the file parameter, Eoln checks for the Enter key being
  1033. pressed at the keyboard.
  1034.  
  1035.  
  1036.  
  1037. Erase procedure
  1038. ----------------------------------------------------------------
  1039. Declaration:  
  1040.      procedure Erase ( var F: File );
  1041.  
  1042. Example:
  1043.      Assign( F, 'KILL-ME.TXT' );
  1044.      {$I-}
  1045.      Erase ( F );
  1046.      ErrCode := IOResult;
  1047.      if  ErrCode <> 0 then { process error condition }
  1048.  
  1049. Purpose:
  1050.      Used in conjunction with Assign, to assign a filename to the file variable
  1051. F, Erase deletes the named file from the DOS directory structure.  Always
  1052. insure that F is closed before calling Erase.
  1053.  
  1054.  
  1055.  
  1056. Exec procedure
  1057. ----------------------------------------------------------------
  1058. Declaration:  
  1059.      procedure Exec ( Path, CmdLine : String );
  1060.  
  1061. Unit:       Dos
  1062.  
  1063. Example:
  1064.  
  1065. { For regular, non-Turbo Vision applications, use this example code }
  1066. SwapVectors;
  1067. Exec( ProgName, ParamStr );
  1068. SwapVectors;
  1069.      
  1070. { Use this example code when using Exec from within Turbo Vision applications }
  1071. ClrScr;
  1072. DoneSysError;
  1073. DoneEvents;
  1074. DoneVideo;
  1075. DoneMemory;
  1076. SetMemTop(HeapPtr);
  1077. SwapVectors;
  1078. Exec( ProgName, ParamStr );
  1079. SwapVectors;
  1080. SetMemTop(HeapEnd);
  1081. InitMemory;
  1082. InitVideo;
  1083. InitEvents;
  1084. InitSysError;
  1085.  
  1086. Purpose:
  1087.      Where Path is the name of a program to execute (with optional drive and
  1088. optional subdirectory path), Exec loads and executes the program specified and
  1089. passes the contents of the CmdLine parameter to that program.  The executed
  1090. program can examine the contents of CmdLine as if it had been launched from the
  1091. DOS command line (See ParamStr).  After control returns from the Exec
  1092. procedure, you can call DosExitCode to see if the program ran successfully.
  1093.  
  1094. Important! Setting Heap Size
  1095.      When using the Exec procedure, you must insure that adequate memory is
  1096. available to launch the desired program.  Normally, Turbo Pascal programs
  1097. allocate all of the available free memory to the heap management system.  When
  1098. this occurs, there's no memory left in which to load and execute another
  1099. program! 
  1100.      The solution is to specify the maximum heap size required by your program.
  1101. If you are using the IDE, select the Options menu, Memory sizes selection, and
  1102. enter a new value for the High heap limit such as 16,384 bytes or what ever is
  1103. appropriate for your application.  The default value is 655,360 bytes.  
  1104.      You may also imbed a compiler directive {$M} to set memory allocation
  1105. within the source code (see Chapters 2 and 3).   If using the command line
  1106. compilers TPC or TPCX (or BPC), you may set the heap size using the command
  1107. line switch /$M to specify the stacksize, and mininum and maximum heap values.
  1108.  
  1109.  
  1110.  
  1111. Exit procedure
  1112. ----------------------------------------------------------------
  1113. Declaration:  
  1114.      procedure Exit;
  1115.  
  1116. Purpose:
  1117.      Call Exit to cause a procedure or function to immediately return back to
  1118. the calling code (be sure to take into account that you may not have a valid
  1119. value assigned for the function result).  Exit is often used to prematurely
  1120. terminate execution of a subroutine when an error has occurred and has the
  1121. equivalent effect of a goto jump to the end statement of the procedure or
  1122. function.
  1123.      When used in the main body of a program, Exit results in termination of
  1124. the program.
  1125. See ExitProc, Halt
  1126.  
  1127.  
  1128.  
  1129. ErrorAddr variable
  1130. ----------------------------------------------------------------
  1131. Declaration:  
  1132.      ErrorAddr: Pointer = nil;
  1133.  
  1134. Purpose:
  1135.      If a program terminates abnormally, ErrorAddr contains the address where
  1136. the error occurred, or possibly nil.  The variable ExitCode contains the error
  1137. code corresponding to the problem that caused the program to terminate.  See
  1138. ExitProc for details.
  1139.  
  1140.  
  1141.  
  1142. ExitCode variable
  1143. ----------------------------------------------------------------
  1144. Declaration:  
  1145.      ExitCode: Integer = 0;
  1146.  
  1147. Purpose:
  1148.      If a program terminates abnormally ExitCode contains the error code
  1149. corresponding to the problem that caused program terminatation.  An ExitCode of
  1150. zero means that no error occurred.  See ExitProc for details.
  1151.  
  1152.  
  1153.  
  1154. ExitProc variable
  1155. ----------------------------------------------------------------
  1156. Declaration:  
  1157.      ExitProc: Pointer = nil;
  1158.  
  1159. Example:
  1160.  
  1161. { Demonstration of installing and using an exit handler procedure. You can use
  1162. this code example in your programs.  Modify ExitHandler                        
  1163. to check for the conditions that your program requires, to close files, or
  1164. whatever exit clean up is needed by your application.                          
  1165. }
  1166.      var
  1167.        LastExitProc : Pointer;
  1168.  
  1169.      procedure ExitHandler; far;
  1170.      begin
  1171.        { Restore previous exit handler address }
  1172.        ExitProc := LastExitProc;
  1173.  
  1174.        { Process exit codes or other operations here }
  1175.        Writeln('ExitCode=',ExitCode);
  1176.        if ErrorAddr = nil  then
  1177.           Writeln('ErrorAddr=nil')
  1178.        else
  1179.           Writeln('ErrorAddr is not nil');
  1180.        {If you display an error message here, be sure to clear
  1181.        the error condition by setting ErrorAddr := nil to
  1182.        prevent other exit handlers from catching this
  1183.        error }
  1184.      end;
  1185.  
  1186.      begin
  1187.        { Install the exit handler procedure }
  1188.        LastExitProc := ExitProc;
  1189.        ExitProc := @ExitHandler;
  1190.  
  1191.        {Main program code goes here as per a normal program}
  1192.        {If Exit is called in the main section, or Halt is called
  1193.        anywhere in the program, or a run-time error occurs, then
  1194.        as part of program termination, your ExitHandler
  1195.        procedure will be called.}
  1196.        ErrorAddr := nil;
  1197.      end.
  1198.  
  1199. Purpose:
  1200.      ExitProc points to a far procedure to be executed as part of the normal or
  1201. abnormal termination of your program, or when the Halt procedure is called. 
  1202. Inside your program's exit handling procedure you can check for abnormal
  1203. program termination by examining the values of ExitCode and ErrorAddr.  If
  1204. ErrorAddr is not equal to nil, then a run-time error occurred and ExitCode
  1205. contains the corresponding error code.  If ErrorAddr is nil and ExitCode is
  1206. non-zero, then the program was terminated by calling Halt and ExitCode is the
  1207. value set by the Halt procedure.  A normal termination produces values of
  1208. ExitCode = 0 and ErrorAddr=nil.
  1209.      When the program exits, the run-time system calls the procedure pointed to
  1210. by ExitProc.  Since a program may have more than one exit handler (such as for
  1211. each unit), they are strung together in a chain of exit procedures.  Upon
  1212. return from the ExitProc procedure, the run-time system checks the value of
  1213. ExitProc and if non-nil, the run-time system again invokes whatever ExitProc
  1214. points to.  Eventually, when there are no more error handlers to invoke,
  1215. ExitProc is set to nil and the run-time system returns to DOS.  
  1216.      This chain of exit procedures is linked together so that each unit, as
  1217. well as the run-time system, may have a chance to perform exit handling clean
  1218. up operations.  Such operations may include closing files, restoring interrupt
  1219. vectors, erasing incomplete files and so on.  The chain is constructed by
  1220. having each unit or program that installs an exit procedure first save the
  1221. address of the existing exit procedure into a local variable before setting
  1222. ExitProc equal to the address of the new exit handler.  Then, inside the exit
  1223. handler, immediately reset ExitProc to the saved value.  In this way, when your
  1224. exit handler finishes up, it returns to the run-time system with ExitProc now
  1225. pointing to the exit handler that was installed before this exit procedure. 
  1226. Thelast exit procedure in the chain (which is the default exit handler), sets
  1227. ExitProc to nil to mark the end of the chain.
  1228.      The example code above shows how an exit procedure is inserted into a
  1229. program.  You may also add such code into a unit's initialization section.  In
  1230. this way, each unit can have its own exit code for cleaning up after itself.
  1231.  
  1232. Important!  Reset ErrorAddr to nil
  1233.      If your own program exit code examines and processes the ErrorAddr and
  1234. ExitCode results, you should set ErrorAddr to nil before leaving your exit code
  1235. procedure.  If you fail to do this, an exit handler located elsewhere in the
  1236. program or run-time system may also display an error message.
  1237.  
  1238.  
  1239.  
  1240. Exp function
  1241. ----------------------------------------------------------------
  1242. Declaration:  
  1243.      function Exp( X: Real ): Real;
  1244.  
  1245. Purpose:
  1246.      Computes and returns the value of e raised to X'th power where Exp(1) is
  1247. approximately equal to 2.7182818.  To compute an arbitrary A to the X'th power,
  1248. use this relation:
  1249.      AX = exp( X * Ln(A) )
  1250. where Ln is the natural logarithm function (see Ln)
  1251. See Ln
  1252.  
  1253.  
  1254.  
  1255. FExpand function
  1256. ----------------------------------------------------------------
  1257. Declaration:  
  1258.      function FExpand ( Path : PathStr );
  1259.  
  1260. Unit:       Dos
  1261.  
  1262. Purpose:
  1263.      To determine the current subdirectory, call FExpand, setting Path to a
  1264. null string, like this:
  1265.      Writeln('Current directory is: ', FExpand ('') );
  1266. FExpand returns as its result the full drive and subdirectory pathname.  If you
  1267. set Path to a filename, FExpand adds that filename to the resulting path to
  1268. create a fully qualified file name.  All values, including Path, are converted
  1269. to upper case characters.  Any errors encountered are returned through
  1270. IOResult.
  1271. See FSplit
  1272.  
  1273.  
  1274.  
  1275. FilePos function
  1276. ----------------------------------------------------------------
  1277. Declaration:  
  1278.      function FilePos ( var F ): Longint;
  1279.  
  1280. Purpose:
  1281.      FilePos returns the current file position or record number within the open
  1282. file F (F may be typed on untyped but not a Text file)   The first position in
  1283. the file is zero.  Any errors encountered are returned through IOResult.
  1284. See Seek
  1285.  
  1286.  
  1287.  
  1288. FileSize function
  1289. ----------------------------------------------------------------
  1290. Declaration:  
  1291.      function FileSize ( var F ) : Longint;
  1292.  
  1293. Example:
  1294.  
  1295.      var         { Display size of a text file }
  1296.        F: File of Char;
  1297.      begin
  1298.        Assign(F,'TEST.PAS');
  1299.        Reset( F );
  1300.        Writeln( FileSize( F ));
  1301.        Readln;
  1302.        Close ( F );
  1303.      end.
  1304.  
  1305. Purpose:
  1306.      Where F is an open typed file, FileSize(F) provides the number of
  1307. components currently stored in the file.  While FileSize does not work on Text
  1308. files, you can cheat a little and open a text file as a typed File of Char, as
  1309. shown above, and then FileSize returns the number of bytes in the text file.
  1310.  
  1311.  
  1312.  
  1313. FillChar procedure
  1314. ----------------------------------------------------------------
  1315. Declaration:  
  1316.      procedure FillChar( var X; Count : Word; Value );
  1317.  
  1318. Example:
  1319.      var
  1320.        AString : String;
  1321.        AnArray : Array[1..30] of Integer;
  1322.      ...
  1323.      FillChar ( AString, SizeOf( AString ), ' ' );
  1324.      AString[0] := Chr(80);
  1325.      FillChar ( AnArray, SizeOf( AnArray), 0 );
  1326.  
  1327. Purpose:
  1328.      FillChar copies Value into Count number of bytes of X, where X is a
  1329. variable of any type, usually an array or record structure.  FillChar is often
  1330. used as a fast and easy method of initializing arrays to zero, or strings to
  1331. blanks.  When initializing string values, make certain that you manually set
  1332. the string's length byte, as shown in the example above.  You can use FillChar
  1333. on part of an array or string by changing the values of X and Count.  For
  1334. example, 
  1335.      FillChar ( AString[70], 10, ' ' );
  1336. sets the last 10 characters of AString to blanks.  Be careful not to run off
  1337. the end of the buffer to which values are written.  To do so is a commom but
  1338. difficult to track down problem.  Particularly since writing past the end of
  1339. one variable will overwrite the contents of the next declared variable in the
  1340. var declarations.  This is difficult to track down because the problem shows up
  1341. as incorrect values in some other variable, not the one on which FillChar is
  1342. used!
  1343.  
  1344.  
  1345.  
  1346. FindFirst
  1347. ----------------------------------------------------------------
  1348. Declaration:  
  1349.      procedure FindFirst( Path : String; Attr : Word; 
  1350.             var S : SearchRec );
  1351.  
  1352. Unit:       Dos
  1353.  
  1354. Example:
  1355. { This is an excerpt from the TVSHELL8 program in the Borland
  1356. Pascal Developer's Guide }
  1357.      var
  1358.        DirEntry : SearchRec;  { Holds the contents of a
  1359.                               directory entry
  1360.                               consisting of filename, size, etc }
  1361.        FileCount : Integer;
  1362.        IsADirectory : Boolean;
  1363.      begin
  1364.        FindFirst( Path + '*.*', AnyFile, DirEntry );
  1365.        FileCount := 0;
  1366.        while  DosError = 0  do
  1367.        begin
  1368.           if  DirEntry.Name[1] <> '.'  then
  1369.             {Add all names other than those beginning with '.'.
  1370.             This eliminates our displaying the '.' and '..'
  1371.             names used by DOS}
  1372.           begin
  1373.             IsADirectory := (DirEntry.Attr and Directory) =
  1374.               Directory;
  1375.             if  IsADirectory  and  FilesOnly  then goto 1;
  1376.             { Note that normally Goto's are to be avoided but in
  1377.             this instance, a single forward jump reduces the
  1378.             number of boolean conditions that need to be tested}
  1379.           if  not IsADirectory  then
  1380.             DirEntry.Name := LowerCase (DirEntry.Name);
  1381.             {We convert file names to lowercase and leave
  1382.             directory names in upper case for ease of reading
  1383.             the directory listing}
  1384.           FileCount := FileCount + 1;
  1385.           Inc(StartingEntry);
  1386.           DirectoryCollection^.AtInsert(StartingEntry,
  1387.             New(PDirectoryEntry, Init( SubLevel, FileCount,
  1388.                  DirEntry )));
  1389.        1:
  1390.        end; { begin }
  1391.      FindNext( DirEntry );
  1392.      end; { begin }
  1393. end; {TDirList.ReadDirectory}
  1394.  
  1395. Purpose:
  1396.      FindFirst is used to initiate a directory search (and should be used in
  1397. conjunction with FindNext).  Path is set to the name of the file to find and
  1398. may contain a combination of characters and DOS wildcard characters * and ?. 
  1399. For example, by setting Path := '*.DOC' you prepare to search for all files
  1400. ending in .DOC.  You can further narrow the search by specifying a file
  1401. attribute, Attr, selected from one of the following constants:
  1402.      ReadOnly    = $01;
  1403.      Hidden   = $02;
  1404.      SysFile     = $04;
  1405.      VolumeID = $08;
  1406.      Directory      = $10;
  1407.      Archive     = $20;
  1408.      AnyFile     = $3F;
  1409. By selecting one of the file attributes you may restrict the search to
  1410. directory names only, read-only files, or any type of file.  You can determine
  1411. if the end of the directory has been reached or no files were found by checking
  1412. the DosError function.  DosError returns 0 if no error occurred, or non-zero if
  1413. an error occurred.
  1414.      The record S returns the filename and other file attributes of the first
  1415. matching file that is located, where SearchRec is defined as:
  1416.      type
  1417.        SearchRec = record
  1418.           Fill: array[1..21] of Byte;
  1419.           Attr : Byte;
  1420.           Time : Longint;
  1421.           Size : Longint;
  1422.           Name : String[12];
  1423.        end;
  1424.  
  1425. See FExpand, FindNext
  1426.  
  1427.  
  1428.  
  1429. FindNext
  1430. ----------------------------------------------------------------
  1431. Declaration:  
  1432.      procedure FindNext (var S: SearchRec );
  1433.  
  1434. Unit:       Dos
  1435.  
  1436. Example:
  1437.      See FindFirst
  1438.  
  1439. Purpose:
  1440.      FindNext is called after an iniitial FindFirst to find subsequent matching
  1441. files.  Always check the value of DosError, as described under FindFirst, to
  1442. determine if no more matching files can be found in subsequent calls to
  1443. FindNext.
  1444. See FindFirst
  1445.  
  1446.  
  1447.  
  1448. Flush procedure
  1449. ----------------------------------------------------------------
  1450. Declaration:  
  1451.      procedure Flush ( var F: Text );
  1452.  
  1453. Purpose:
  1454.      When you write output to a text file, the data may not be immediately
  1455. written to disk.  Instead, the data is temporarily stored in an internal memory
  1456. buffer.  When the buffer becomes full, or the file is closed, the buffer is
  1457. physcially transferred to the disk.  To force the buffer to be "emptied" to
  1458. disk, call the Flush procedure.  By calling Flush, you insure that the data on
  1459. disk are up to date after each Write or Writeln.
  1460. See SetTextBuf
  1461.  
  1462.  
  1463.  
  1464. Frac function
  1465. ----------------------------------------------------------------
  1466. Declaration:  
  1467.      function Frac ( X: Real ): Real;
  1468.  
  1469. Example:
  1470.      Writeln( Frac( Pi ):8:7 );
  1471. outputs,
  1472.      0.1415927
  1473.  
  1474. Purpose:
  1475.      Use Frac to obtain the fractional part of a real valued expression.  Use
  1476. Int(X) to obtain the integer part of the real value.
  1477. See Int
  1478.  
  1479.  
  1480.  
  1481. FreeMem procedure
  1482. ----------------------------------------------------------------
  1483. Declaration:  
  1484.      procedure FreeMem (var P: Pointer; Size : Word );
  1485.  
  1486. Purpose:
  1487.      FreeMem disposes of the memory block pointed to by P, where P was
  1488. initialized by calling GetMem.  The Size parameter must be the exact size in
  1489. bytes used to request the allocation with GetMem.  See Dispose for a discussion
  1490. of important restrictions concerning the value of P before and after the
  1491. allocation.  
  1492. See Dispose, GertMem, New
  1493.  
  1494.  
  1495.  
  1496.  
  1497. FSearch function
  1498. ----------------------------------------------------------------
  1499. Declaration:  
  1500.      function FSearch( Path: PathStr; DirList: String ) :
  1501.           PathStr;
  1502.  
  1503. Unit:       Dos
  1504.  
  1505. Example:
  1506.    1  { FSEARCH.PAS }
  1507.    2  Program DemoSearch;
  1508.    3  { Demonstrates an algorithm to locate a program's required data and
  1509.    4    configuration files through the use of the DosVersion function,
  1510.    5    ParamStr function, FSplit procedure and FSearch function.  This
  1511. algorithm
  1512.    6    assumes that the required config. files are kept in the same directory
  1513.    7    as the .EXE file.
  1514.    8  }
  1515.    9  uses
  1516.   10    Dos;
  1517.   11  
  1518.   12  const
  1519.   13    { This is the filename that we must locate }
  1520.   14    DataFilename = 'SCRATCH.DAT';
  1521.   15  
  1522.   16  var
  1523.   17    Path : PathStr;
  1524.   18    Directory : DirStr;
  1525.   19    FName : NameStr;
  1526.   20    Extension : ExtStr;
  1527.   21    F : File;
  1528.   22  
  1529.   23  begin
  1530.   24  
  1531.   25    Path := '';
  1532.   26    {$I-}
  1533.   27    { First, check the current directory }
  1534.   28    Assign( F, DataFilename );
  1535.   29    Reset( F );
  1536.   30    if IoResult <> 0 then
  1537.   31    { if not found here, then continue checking ... }
  1538.   32    begin
  1539.   33      if Lo(DosVersion) >= 3.0 then
  1540.   34      { if running >= DOS 3.0, then use ParamStr(0) to get location of
  1541.   35        the .EXE file and assume that directory for the data files }
  1542.   36      begin
  1543.   37        FSplit ( ParamStr(0), Directory, FName, Extension );
  1544.   38        Path := Directory;
  1545.   39      end
  1546.   40      else
  1547.   41        { Otherwise, search through the list of directories in the DOS
  1548.   42          PATH statement.  The .EXE, and hence, its data files, must
  1549.   43          have been booted from one of these directories. }
  1550.   44        Path := FSearch ( DataFileName, GetEnv('PATH') );
  1551.   45    end
  1552.   46    else
  1553.   47    Close ( F );
  1554.   48  
  1555.   49    Writeln('Path = ', Path );
  1556.   50  end.
  1557.  
  1558. Purpose:
  1559.      FSearch scans through a list of directories, specified by DirList, and
  1560. returns either the full filename, including the subdirectory name, or the null
  1561. string if the file could not be found.
  1562.      A typical use of FSearch is when your application first starts to run and
  1563. needs to find its various data files.  Most applications store their
  1564. configuration and other file data in the subdirectory where the .EXE executable
  1565. is located.  You could, of course, hard code a subdirectory name into your
  1566. program, such as 'C:\MYAPP\'.  But this precludes letting users place the
  1567. application in a directory of their choosing.  So instead of hard coding the
  1568. subdirectory name, most applications use an algorithm such as the following:
  1569. Step 1:  First look in the current directory.  If the data files are not found,
  1570. then continue to Step 2.
  1571. Step 2:  If running DOS 3.0 or newer, use ParamStr(0) to fetch the full path
  1572. and file name of the .EXE that is currently running.  Then use FSplit to
  1573. extract the subdirectory name and use this as the directory where the data
  1574. files should be located.
  1575. Step 3:  If running an older version of DOS, then search through the list of
  1576. subdirectories contained in the DOS PATH statement.  In order for the program
  1577. to be launched, it must exist in one of the path directories.
  1578. See DosVersion, FSplit, Lo, ParamCount, ParamStr
  1579.  
  1580.  
  1581.  
  1582. FSplit function
  1583. ----------------------------------------------------------------
  1584. Declaration:  
  1585.      procedure FSplit ( Path : PathStr; var Dir: DirStr;
  1586.                   var Name: NameStr; var Ext: ExtStr );
  1587.           type
  1588.             PathStr = String[79];
  1589.             DirStr = String[67];
  1590.             NameStr = String[8];
  1591.             ExtStr = String[4];
  1592.  
  1593. Unit:       Dos
  1594.  
  1595. Example:
  1596.      See FSearch
  1597.  
  1598. Purpose:
  1599.      Where Path contains a potentially fully qualified filename, including a
  1600. leading directory name, FSplit, splits apart the filename and returns 3
  1601. separate components:
  1602.      Dir    - the directory name part of the filename
  1603.      Name - the filename minus the extension
  1604.      Ext    - the filename extension including the leading period character.
  1605. If Path does not contain some of the components, such as a filename extension,
  1606. then the corresponding return variable is set to the null string ''.
  1607.  
  1608.  
  1609.  
  1610. GetCBreak procedure
  1611. ----------------------------------------------------------------
  1612. Declaration:  
  1613.      procedure GetCBreak (var Break: Boolean);
  1614.  
  1615. Unit:       Dos
  1616.  
  1617. Purpose:
  1618.      The DOS operating system periodically checks for a the Ctrl-Break key
  1619. combination being pressed during program execution.  As you know, pressing
  1620. Ctrl-Break interrupts the flow of program execution.  However, the actual
  1621. processing of the Ctrl-Break key depends on the state of a DOS internal
  1622. variable.  GetCBreak returns the current state of this flag:  if set to True,
  1623. DOS checks for Ctrl-Break at every DOS system call; if False, DOS checks only
  1624. during input/output operations to the console (CON:), printer (LPT:) or
  1625. communications ports (COMx:).  To change the state of Ctrl-Break processing
  1626. flag, call SetCBreak.  Also see CheckBreak.
  1627.  
  1628.  
  1629.  
  1630. GetDate procedure
  1631. ----------------------------------------------------------------
  1632. Declaration:  
  1633.      procedure GetDate(var Year, Month, Day, DayofWeek: Word);
  1634.  
  1635. Unit:       Dos
  1636.  
  1637. Purpose:
  1638.      GetDate fetches the system date (you were expecting that, weren't you?)
  1639. from the current DOS date setting, returning the Year as a value from 1980 to
  1640. 2099, the Month from 1 to 12, the Day from 1 to 31 and the DayOfWeek value from
  1641. 0 (Sunday) to 6 (Saturday).
  1642. See GetTime, SetDate, SetTime
  1643.  
  1644.  
  1645.  
  1646. GetDir procedure
  1647. ----------------------------------------------------------------
  1648. Declaration:  
  1649.      procedure GetDir( D: Byte; var S: String );
  1650.  
  1651. Purpose:
  1652.      Use GetDir to determine the currently active subdirectory on a specific
  1653. disk drive.  By setting D to 0 for drive A, 1 for drive B, 2 for drive C, and
  1654. so forth, GetDir returns the current subdirectory in drive S.  The default
  1655. return value is '\', even if D specifies an invalid drive, so be certain that D
  1656. is an appropriate value for the system on which the program is running.  
  1657. See ChDir
  1658.  
  1659.  
  1660.  
  1661. GetEnv function
  1662. ----------------------------------------------------------------
  1663. Declaration:  
  1664.      function GetEnv(EnvVar : String) : String;
  1665.  
  1666. Unit:       Dos
  1667.  
  1668. Example:
  1669.  
  1670.      CurrentPath := GetEnv('PATH');
  1671.      Command := GetEnv('COMSPEC');
  1672.  
  1673. Also see FSearch for another example.
  1674.  
  1675. Purpose:
  1676.      DOS maintains a set of environment variables such as PATH, COMSPEC, and so
  1677. on.  GetEnv looks up and returns the value of the environment variable
  1678. specified by EnvVar.
  1679.  
  1680.  
  1681.  
  1682. GetFAttr procedure
  1683. ----------------------------------------------------------------
  1684. Declaration:  
  1685.      procedure GetFAttr( var F; var Attr: Word );
  1686.  
  1687. Unit:       Dos
  1688.  
  1689. Example:
  1690.      Assign(F, 'SCRATCH.DAT' );
  1691.      GetFAttr( F, Attr );
  1692.      if (Attr and Archive)<>0 then {archive bit set}
  1693.      else
  1694.      if (Attr and ReadOnly)<>0 then {read only file}
  1695.      ...
  1696.  
  1697. Purpose:
  1698.      Every file on the system has associated with it a set of file attributes. 
  1699. These attributes indicate if the file is read-only, hidden, or perhaps a
  1700. directory name.  You can obtain a file's attribute settings by calling
  1701. GetFAttr, where F is a file variable to which a filename has been assigned with
  1702. Assign (but should not be open).  The attribute value is returned in Attr, as a
  1703. bit pattern.  You can check for individual bits using these predefined constant
  1704. identifers:
  1705.      ReadOnly    =  $01;
  1706.      Hidden   =  $02;
  1707.      SysFile     =  $04;
  1708.      VolumeID =  $08;
  1709.      Directory      = $10;
  1710.      Archive     =  $20;
  1711.      AnyFile     = $3F;
  1712. AnyFile is typically used with FindFirst and FindNext and doesn't really have
  1713. any use here. Its possible for a file to have more than one attribute bit set,
  1714. such as ReadOnly and Hidden, so be sure to check multiple attribute settings if
  1715. necessary.  Also check DosError in case an error occurs.
  1716.      You can set specific file attributes by calling SetFAttr.  To get and set
  1717. the file's access date and time, see GetFTime and SetFTime.
  1718.  
  1719.  
  1720.  
  1721. GetFTime procedure
  1722. ----------------------------------------------------------------
  1723. Declaration:  
  1724.      procedure GetFTime(var F; var Time: Longint );
  1725.  
  1726. Unit:       Dos
  1727.  
  1728. Example:
  1729.      uses dos;
  1730.      var
  1731.        F : Text;
  1732.        LFileInfo : Longint;
  1733.        DFileInfo : DateTime; { declared in Dos unit }
  1734.      begin
  1735.        Assign( F, 'FSEARCH.PAS' );
  1736.        Reset( F );
  1737.        GetFTime ( F, LFileInfo );
  1738.        UnpackTime ( LFileInfo, DFileInfo );
  1739.        with DFileInfo do
  1740.           Writeln(Month, '-', Day, '-',
  1741.              Year, ' ', Hour:2,':',Min:2,':',Sec:2);
  1742.        Readln;
  1743.      end.
  1744.  
  1745. Purpose:
  1746.      Every file has associated with it, a date and time stamp indicating when
  1747. the file was last written to.  You can fetch this date and time information by
  1748. calling GetFTime, passing a open file identifier.  GetFTime returns the date
  1749. and file time packed into a Longint value.  Use UnpackTime to translate the
  1750. packed representation into individual date and time components (see the example
  1751. above, as well as PackTime and UnpackTime).
  1752.  
  1753.  
  1754.  
  1755. GetIntVec procedure
  1756. ----------------------------------------------------------------
  1757. Declaration:  
  1758.      procedure GetIntVec(IntNo: Byte; var Vector: Pointer);
  1759.  
  1760. Unit:       Dos
  1761.  
  1762. Purpose:
  1763.      Use GetIntVec to obtain the current address stored in the interrupt number
  1764. IntNo, ranging from 0 up to 255.  GetIntVec returns the address as pointer
  1765. value in Vector.  Call SetIntVec to set a specific interrupt vector.
  1766.  
  1767.  
  1768.  
  1769. GetMem procedure
  1770. ----------------------------------------------------------------
  1771. Declaration:  
  1772.      procedure GetMem(var P: Pointer; Size: Word);
  1773.  
  1774. Example:
  1775.      type
  1776.        TBuffer = Array[0..65521] of char;
  1777.        PBuffer = ^TBuffer;
  1778.      var
  1779.        TextBuffer : PBuffer;
  1780.        BufSize    : Word;
  1781.        I          : Integer;
  1782.      begin
  1783.        { Depending on some condition, such as low memory, or
  1784.        user command, you
  1785.        set BufSize at run-time to the exact size of the buffer
  1786.        that is needed. }
  1787.  
  1788.        BufSize := 35000;
  1789.        GetMem ( TextBuffer, BufSize );
  1790.  
  1791.        { Perform needed processing on TextBuffer 
  1792.        Be certain that you index the buffer only in the range
  1793.        from 0
  1794.        to BufSize.  Even though TBuffer is defined to hold up to
  1795.        65,521 bytes,
  1796.        we have only allocated enough memory for the first 35,000
  1797.        bytes. }
  1798.        For I := 0 to BufSize do
  1799.           TextBuffer^[I] := ' ';
  1800.        
  1801.        { Return the buffer memory back to the free space on the
  1802.        heap }
  1803.        FreeMem ( TextBuffer, BufSize );
  1804.  
  1805.        Readln;
  1806.      end.
  1807.  
  1808. Purpose:
  1809.      GetMem allocates a memory block from the heap sufficient to hold Size
  1810. bytes (up to a maximum of 65,521 bytes), and returns a pointer to the allocated
  1811. memory in variable parameter P.  While most dynamic variable allocations are
  1812. made with the New procedure, you can use GetMem for allocating buffers whose
  1813. size is not known until program execution.  The example above shows how to
  1814. allocate a dynamically sized array of char.  You can use this code fragment to
  1815. allocate other types of data structures.  To allocate a single record, set
  1816. BufSize := SizeOf(recordstructuretype).  To create a dynamically allocated
  1817. array of records, write:
  1818.      BufSize := SizeOf(recordstructuretype) * MaximumElements;
  1819. where MaximumElements is the largest array index that you will need.  Its
  1820. important when multiplying these values to insure that you do not exceed 65,521
  1821. bytes in size.  To create an array of other data types, such as Integer,
  1822. Longint or Real, substitute the appropriate data type in the SizeOf expression
  1823. shown above.
  1824. See Dispose, FreeMem, Mark, New, Release
  1825.  
  1826.  
  1827.  
  1828. GetTime procedure
  1829. ----------------------------------------------------------------
  1830. Declaration:  
  1831.      procedure GetTime(var Hour, Minute, Second, Sec100: Word);
  1832.  
  1833. Unit:       Dos
  1834.  
  1835. Purpose:
  1836.      The DOS operating system maintains a system clock to keep track of the
  1837. time in resolution down to 100th of a second.  By calling GetTime you can
  1838. obtain the current values for Hour, Minute, Second and hundredth's of a second.
  1839. See GetDate, PackTime, SetDate, SetTime, UnpackTime
  1840.  
  1841.  
  1842.  
  1843. GetVerify procedure
  1844. ----------------------------------------------------------------
  1845. Declaration:  
  1846.      procedure GetVerify( var Verify: Boolean );
  1847.  
  1848. Unit:       Dos
  1849.  
  1850. Purpose:
  1851.      DOS can optionally verify that every disk write operation is correctly
  1852. performed by having the disk controller read the disk record back into memory
  1853. and comparing the result to what it wrote.  You can check the current setting
  1854. of the DOS verify flag by calling GetVerify, which returns Verify set to True
  1855. when disk writes are being verified, and False if disk writes are not verified.
  1856. Disk write verification is, of course, quite time consuming and can be turned
  1857. on or off by calling SetVerify.   Because of the slowness that this can cause
  1858. (all disk writes take twice as long), most DOS users leave verification turned
  1859. off.
  1860.  
  1861.  
  1862.  
  1863. GotoXY procedure
  1864. ----------------------------------------------------------------
  1865. Declaration:  
  1866.      procedure Gotoxy (X, Y: Byte);
  1867.  
  1868. Unit:       Crt
  1869.  
  1870. Purpose:
  1871.      Gotoxy moves the text cursor to a new screen location specified by the
  1872. coordinate pair (X,Y) (relative to the current settings of the Window
  1873. procedure).  The screen coordinates range from (1,1) in the upper left corner
  1874. to (80,25) at the lower right corner when using the standard 80x25 text screen
  1875. size.  The maximum values vary depending on the type and mode settings of the
  1876. video monitor.  X increases from left to right and Y increases from top to
  1877. bottom.
  1878.      You can obtain the current cursor position by calling WhereX and WhereY.
  1879. See Window
  1880.  
  1881.  
  1882.  
  1883. Halt procedure
  1884. ----------------------------------------------------------------
  1885. Declaration:  
  1886.      procedure Halt [ (ExitCode: Word); ]
  1887.  
  1888. Purpose:
  1889.      Halt stops your program from executing and returns to DOS, optionally
  1890. setting the program's exit code to ExitCode.  Be sure to see ExitCode and
  1891. ExitProc for additional details regarding program exit handling.
  1892. See Exit, ExitCode, RunError
  1893.  
  1894.      
  1895.  
  1896. HeapError variable
  1897. ----------------------------------------------------------------
  1898. Declaration:  
  1899.      HeapError : is a pointer to a function having this structure
  1900.           function HeapFunc(Size: Word): Integer; far;
  1901.  
  1902. Purpose:
  1903.      HeapError may be set to point to a special far function to assist with
  1904. handling of out of memory errors that may arise when attempting to allocate
  1905. dynamic variables with New or GetMem.   See "Pointers and Memory Management" in
  1906. Chapter 3 for details.
  1907.  
  1908.  
  1909.  
  1910. Hi function
  1911. ----------------------------------------------------------------
  1912. Declaration:  
  1913.      function Hi ( X ) : Byte;
  1914.  
  1915. Purpose:
  1916.      Where X is either an Integer or Word value, Hi(X) returns the high byte of
  1917. the 2 byte data value.  Lo(X) returns the low byte value.
  1918. See Lo, Swap
  1919.  
  1920.  
  1921.  
  1922. HighVideo procedure
  1923. ----------------------------------------------------------------
  1924. Declaration:  
  1925.      procedure HighVideo;
  1926.  
  1927. Unit:       Crt
  1928.  
  1929. Purpose:
  1930.      Text is written to the screen in 1 of 8 possible colors (see TextColor). 
  1931. The values 0 to 7 are the basic color set, with the next 8 values, 8 to 15,
  1932. defining high-intensity or bright renditions of the basic color set.  When
  1933. writing text in one of the basic colors (0 to 7), calling HighVideo effectively
  1934. adds 8 to the current text color.  This may be turned off by calling LowVideo
  1935. or NormVideo.
  1936. See LowVideo, NormVideo, TextBackground, TextColor
  1937.  
  1938.  
  1939.  
  1940. Inc procedure
  1941. ----------------------------------------------------------------
  1942. Declaration:  
  1943.      procedure Inc (var X [; N: Longint ] );
  1944.  
  1945. Purpose:
  1946.      Inc provides an optimized method of incrementing the value of a variable. 
  1947. When used in the form Inc(X), the value of X is increased by 1.  This is
  1948. equivalent to writing,
  1949.      X := X + 1;
  1950. When used in the form Inc(X, N), the value of X is increased by N.  This is
  1951. equivalent to writing,
  1952.      X := X+ N;
  1953. See Dec
  1954.  
  1955.  
  1956.  
  1957. Insert procedure
  1958. ----------------------------------------------------------------
  1959. Declaration:  
  1960.      procedure Insert( Source: String; var S: String; 
  1961.                     Index: Integer);
  1962.  
  1963. Example:
  1964.  
  1965.      AString := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  1966.      Insert( '0123456789', AString, 14 );
  1967.      Writeln( AString );
  1968.  
  1969. produces this output,
  1970.  
  1971.      ABCDEFGHIJKLM0123456789NOPQRSTUVWXYZ
  1972.  
  1973. Purpose:
  1974.      Use Insert to place one string inside of another.  Insert copies Source
  1975. into S starting at Index, pushing the existing characters in S to the right.
  1976. See Concat, Copy, Delete, Length, Pos
  1977.  
  1978.  
  1979.  
  1980. InsLine procedure
  1981. ----------------------------------------------------------------
  1982. Declaration:  
  1983.      procedure InsLine;
  1984.  
  1985. Unit:     Crt
  1986.  
  1987. Example:
  1988.      Gotoxy (1, 10);
  1989.      InsLine; { Insert a blank line at line 10 }
  1990.  
  1991. Purpose:
  1992.      Use InsLine to scroll text on the screen downwards (also see DelLine to
  1993. scroll text upwards), inserting a new blank line in the current TextBackground
  1994. color.  Use Gotoxy to move the cursor to the screen or window location where
  1995. the insert line operation should begin.  You can use InsLine within a screen
  1996. window (see Window) to scroll only a portion of the screen.
  1997. See DelLine, Gotoxy, TextBackground, Window
  1998.  
  1999.  
  2000.  
  2001. Int function
  2002. ----------------------------------------------------------------
  2003. Declaration:  
  2004.      function Int( X: Real ) : Real;
  2005.  
  2006. Purpose:
  2007.      Removes the fractional part of X and returns the integer portion of X as
  2008. the result.  For example, Int(Pi) returns 3, Int(-7.,89) returns -7.
  2009. See Frac, Round, Trunc
  2010.  
  2011.  
  2012.  
  2013. Intr procedure
  2014. ----------------------------------------------------------------
  2015. Declaration:  
  2016.      procedure Intr(IntNo: Byte; var Regs: Registers);
  2017.  
  2018. Unit:       Dos
  2019.  
  2020. Example:
  2021.      uses
  2022.        Dos;
  2023.      const
  2024.        StartLine = 4;         { Top scan line }
  2025.        EndLine = 8; { Bottom scan line }
  2026.      var
  2027.        Reg : Registers;
  2028.      begin
  2029.        { Demonstration of changing the shape of the on-screen
  2030.          text cursor }
  2031.        Reg.AH := $01;
  2032.        Reg.CH := StartLine;
  2033.        Reg.CL := EndLine;
  2034.        Intr ( $10, Reg );
  2035.        Readln;
  2036.      end.
  2037.  
  2038. Purpose:
  2039.      Use Intr to access the software interrupt specified by IntNo.  Regs is of
  2040. type Register, which is a case-variant record structure for representing the
  2041. CPU registers,  defined as:
  2042. type
  2043.      Registers = record
  2044.        case Integer of
  2045.           0: (AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: Word);
  2046.           1: (Al, AH, BL, BH, CL, CH, DL, DH: Byte);
  2047.      end;
  2048. Note that the SS and SP registers are not available in this structure and
  2049. cannot be used in conjunction with BIOS and DOS calls.
  2050.      The example code, above, uses Int 10H Subfunction 01H Set Cursor Type to
  2051. change the shape of the text mode cursor.  The cursor shape is defined as a
  2052. block between the StartLine and EndLine values, where the top line is line 0
  2053. and the bottom or EndLine is determined by the display adaptor and screen
  2054. resolution in use.  For CGA equivalent displays, characters are 8 pixels high,
  2055. hence, these values range from 0 to 7.
  2056.      For complete details on DOS and BIOS software interrupt function calls,
  2057. see DOS Programmer's Reference, by Terry Dettmann and Jim Kyle (Que Books,
  2058. 1989). 
  2059.  
  2060.  
  2061.